// stores/farm.js - 支持多场景版本
import { defineStore } from 'pinia'
import { ref } from 'vue'
import dataAPI from '@/api/dataAPI'
import { useAuthStore } from '@/stores/auth'

export const useFarmStore = defineStore('farm', () => {
    const farmData = ref({})
    const isLoading = ref(false)
    const isSystemOnline = ref(true)
    const lastUpdateTime = ref('')

    const authStore = useAuthStore()

    // 获取当前用户ID
    const getCurrentUserId = () => {
        return '999' // 保持原有逻辑
    }

    // 保存数据到本地存储（保持原有）
    const saveToLocalStorage = (data, dataType = 'environmental') => {
        try {
            const storageKey = `farm_last${dataType.charAt(0).toUpperCase() + dataType.slice(1)}Data`
            localStorage.setItem(storageKey, JSON.stringify(data))
            console.log(`✅ 保存${dataType}数据到本地存储成功:`, data)
        } catch (err) {
            console.error(`保存${dataType}数据到本地存储失败:`, err)
        }
    }

    // 从本地存储加载数据（保持原有）
    const loadFromLocalStorage = (dataType = 'environmental') => {
        try {
            const storageKey = `farm_last${dataType.charAt(0).toUpperCase() + dataType.slice(1)}Data`
            const lastData = localStorage.getItem(storageKey)
            if (lastData) {
                console.log(`✅ 从本地存储加载${dataType}数据成功`)
                return JSON.parse(lastData)
            }
        } catch (err) {
            console.error(`从本地存储加载${dataType}数据失败:`, err)
        }
        return null
    }

    // 数据转换函数 - 通用版本（保持原有）
    const transformFarmData = (backendData, scene) => {
        console.log(`🔍 ${scene}转换前的原始数据:`, backendData)

        let data = {}

        if (backendData && Array.isArray(backendData.data) && backendData.data.length > 0) {
            data = backendData.data[0] // 取第一条数据
            console.log(`📦 ${scene}取数组第一条数据:`, data)
        } else {
            console.warn(`⚠️ ${scene}没有有效数据`)
            return getDefaultDataForScene(scene)
        }

        const transformed = mapDataByScene(data, scene)
        console.log(`🔄 ${scene}转换后的数据:`, transformed)
        return transformed
    }

    // 根据场景获取默认数据（保持原有）
    const getDefaultDataForScene = (scene) => {
        const defaults = {
            home: {
                humidity: null,
                temperature: null,
                soilMoisture: null,
                coConcentration: null,
                timestamp: null
            },
            pigsty: {
                temperature: null,
                humidity: null,
                coConcentration: null,
                timestamp: null
            },
            plantation: {
                temperature: null,
                humidity: null,
                soilMoisture: null,
                timestamp: null
            },
            fishpond: {
                soilMoisture: null,
                airHumidity: null,
                airTemperature: null,
                timestamp: null
            }
        }
        return defaults[scene] || defaults.home
    }

    // 根据场景映射数据字段（保持原有）
    const mapDataByScene = (data, scene) => {
        const mappings = {
            home: {
                humidity: data?.airHumidity ?? null,
                temperature: data?.airTemperature ?? null,
                soilMoisture: data?.soilMoisture ?? null,
                coConcentration: data?.carbonMonoxide ?? null,
                timestamp: data?.timestamp ?? null
            },
            pigsty: {
                temperature: data?.airTemperature ?? data?.temperature ?? null,
                humidity: data?.airHumidity ?? data?.humidity ?? null,
                coConcentration: data?.carbonMonoxide ?? data?.coConcentration ?? null,
                timestamp: data?.timestamp ?? null
            },
            plantation: {
                temperature: data?.airTemperature ?? data?.temperature ?? null,
                humidity: data?.airHumidity ?? data?.humidity ?? null,
                soilMoisture: data?.soilMoisture ?? null,
                lightIntensity: data?.lightIntensity ?? data?.light ?? null,
                timestamp: data?.timestamp ?? null
            },
            fishpond: {
                soilMoisture: data?.soilMoisture ?? data?.moisture ?? null,
                airHumidity: data?.airHumidity ?? null,
                airTemperature: data?.airTemperature ?? null,
                timestamp: data?.timestamp ?? null
            }
        }
        return mappings[scene] || mappings.home
    }

    // 通用数据获取方法（保持原有）
    const fetchSceneData = async (scene) => {
        try {
            isLoading.value = true
            const userId = getCurrentUserId()

            console.log(`🔄 开始获取${scene}场景数据...`)
            const result = await dataAPI.getSceneData(scene, userId)
            console.log(`📊 ${scene}场景API响应:`, result)

            if (result && result.success) {
                console.log(`✅ ${scene}场景API请求成功`)

                const transformedData = transformFarmData(result, scene)
                farmData.value = transformedData

                saveToLocalStorage(transformedData, scene)

                isSystemOnline.value = true
                lastUpdateTime.value = new Date().toLocaleString('zh-CN')

                console.log(`🎉 ${scene}场景最终数据:`, farmData.value)
                return transformedData
            } else {
                console.error(`❌ ${scene}场景API返回失败`)
                throw new Error(result?.message || `${scene}场景API请求失败`)
            }

        } catch (err) {
            console.error(`🚨 获取${scene}场景数据失败:`, err)
            isSystemOnline.value = false

            const lastData = loadFromLocalStorage(scene)
            if (lastData) {
                console.log(`🔄 ${scene}场景使用本地存储数据:`, lastData)
                farmData.value = lastData
                return lastData
            } else {
                console.log(`💥 ${scene}场景没有本地存储数据`)
                const defaultData = getDefaultDataForScene(scene)
                farmData.value = defaultData
                return defaultData
            }
        } finally {
            isLoading.value = false
        }
    }

    // 各个场景的专用方法（保持原有）
    const fetchEnvironmentalData = async () => {
        return fetchSceneData('home')
    }

    const fetchPigstyData = async () => {
        return fetchSceneData('pigsty')
    }

    const fetchPlantationData = async () => {
        return fetchSceneData('plantation')
    }

    const fetchFishpondData = async () => {
        return fetchSceneData('fishpond')
    }

    // ==============================================
    // 新增：获取历史数据（仅前端处理，不修改后端）
    // ==============================================
    const fetchHistoryData = async (dataType, limit = 20) => {
        try {
            isLoading.value = true
            const userId = getCurrentUserId()
            const scene = 'home' // 固定为家庭客厅场景

            // 1. 调用现有接口，获取该用户home场景的所有数据
            console.log(`🔄 开始获取${scene}场景${dataType}历史数据...`)
            const result = await dataAPI.getSceneData(scene, userId)

            if (!result || !result.success || !Array.isArray(result.data)) {
                console.error(`❌ 获取历史数据失败：接口返回异常`, result)
                return []
            }

            // 2. 前端数据处理：按时间倒序、取最后N条、提取对应字段
            const allData = result.data
                .filter(item => item.timestamp) // 过滤掉无时间戳的数据
                // 按时间戳倒序（最新的数据在前）
                .sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp))
                // 取最后N条（因为倒序后，slice(0, limit) 就是最新的limit条）
                .slice(0, limit)
                // 格式转换：适配图表需要的 {time: 时间字符串, value: 数值}
                .map(item => {
                    // 字段映射：前端传入的dataType → 后端返回的字段名
                    const fieldMap = {
                        temperature: 'airTemperature', // 前端temperature → 后端airTemperature
                        humidity: 'airHumidity',       // 前端humidity → 后端airHumidity
                        coConcentration: 'carbonMonoxide' // 前端coConcentration → 后端carbonMonoxide
                    }
                    const backendField = fieldMap[dataType] || dataType
                    return {
                        time: new Date(item.timestamp).toLocaleString('zh-CN'), // 时间格式化
                        value: item[backendField] ?? null // 提取数值（无数据则为null）
                    }
                })
                // 过滤掉无数值的数据
                .filter(item => item.value !== null)

            console.log(`✅ 成功获取${dataType}历史数据（${allData.length}条）`, allData)
            return allData
        } catch (err) {
            console.error(`🚨 获取${dataType}历史数据失败`, err)
            return []
        } finally {
            isLoading.value = false
        }
    }

    return {
        farmData,
        isLoading,
        isSystemOnline,
        lastUpdateTime,
        fetchEnvironmentalData,
        fetchPigstyData,
        fetchPlantationData,
        fetchFishpondData,
        fetchSceneData,
        fetchHistoryData // 导出新增方法
    }
})